home *** CD-ROM | disk | FTP | other *** search
/ The Fatted Calf / The Fatted Calf.iso / Applications / Graphics / MapMaker / Source / fractal.c < prev    next >
Text File  |  1994-04-29  |  3KB  |  112 lines
  1.  
  2. /*
  3. ** fractal.c 
  4. ** for project : MapMaker  
  5. ** using NeXTStep and mach Unix.
  6. ** CPSC 414 Assignment No. 4 Project
  7. **  
  8. ** Programmed by Bradley Head and Thomas Burkholder 
  9. ** December 1990
  10. */
  11.  
  12. #import <math.h>
  13. #import <stdlib.h>
  14. #import "pointdata.h"
  15. #import "proj.h"
  16. #import "fractal.h"
  17.  
  18.  
  19.   float MinLen = 10*toRADS;    /* set global variable to initial value */
  20.  
  21.  FractValues fvalues;
  22.  /****************************************************/ 
  23.  
  24.  int setFValues(int Fractalize, float H, float StdDev) {    /* set up constants for Fractalizing */
  25.      fvalues.Fractalize = Fractalize;
  26.     fvalues.H = H;
  27.     fvalues.StdDev = StdDev;
  28.     }
  29.     
  30. float Gauss() {             /* returns a random number between -0.5 & 0.5  */
  31. double intpart;                    /* with  mean at 0.0 */
  32. float g = 0.0;
  33. int i;
  34.  
  35. for (i = 1;i <= 23;i++) 
  36.     g += rand() /(RAND_MAX + 1.0);
  37.     g = g/23.0 - 0.5;         /* set mean to 0.0 */
  38. return g;
  39. }
  40.  
  41.  
  42. void  Fract(Point a, Point b, float sdev, PointList *plist) 
  43. {
  44. /*  this function is used to fractalize
  45. ** line segments
  46. */
  47. float r;
  48. float Len;
  49. Point n;
  50. Len = sqrt((b.x - a.x)*(b.x - a.x) + (b.y - a.y)*(b.y - a.y));    /* compute length between points */
  51. if  (Len  < (MinLen)) {         /* terminating condition: don't fractalize less than this length */
  52.     addToPointList(plist,&b);    /* add the point to list */
  53.     }
  54.     else {
  55.         sdev *= fvalues.f;        /* scale Sdev by f */
  56.         r = Gauss()*sdev;        /* get gaussian pseudo-random number */
  57.         n.x = 0.5*(a.x + b.x) - r*(b.y - a.y);    /* compute the middle point */
  58.         n.y = 0.5*(a.y + b.y) + r*(b.x - a.x);
  59.         n.pen = DOWN;
  60.         Fract(a,n,sdev,plist);    /* call Fract on segment between a and n */
  61.         Fract(n,b,sdev,plist);    /* call Fract on segment between b and n */
  62.     }
  63. }
  64.  
  65.  
  66. void insertFSegments(PointList *pin, PointList *pout, ProjParam *pparam)  {
  67.  
  68. /* This function segments the input list either using a parametric 
  69. ** insertion technique
  70. ** or by fractalizing the line segments of the input list
  71. ** the segmented list is returned as the point list pout 
  72. ** which can then be plotted
  73. */
  74. float step,t;
  75. float Len;
  76. Point p;
  77. Point *p1;
  78. Point *p2;
  79. int vertex = 0;
  80. MinLen =10*toRADS*fabs(pparam->radius);  /* compute minimum length to decide if segmenting */
  81. while (gotoPointInList(pin,vertex,&p1)) {    /* while there is a list to segment */
  82.     addToPointList(pout,p1);            /* add the first point to the output list */
  83.     vertex++;
  84.      if (gotoPointInList(pin,vertex,&p2))    /* if there is a next vertex then continue */
  85.          {
  86.         Len = sqrt((p2->x - p1->x)*(p2->x - p1->x) + (p2->y - p1->y)*(p2->y - p1->y));
  87.         if (fvalues.Fractalize) {
  88.             fvalues.f  = exp((0.5 - fvalues.H)*log(2.0));    /* Fractalize stuff to get f */
  89.             if (p1->pen == DOWN)                                                            
  90.                 Fract(*p1, *p2, fvalues.StdDev, pout);    /* call the recursive function Fract */
  91.             else 
  92.                 addToPointList(pout,p2);    /* if the pen command is up don't fractalize; just move and store */
  93.             }
  94.         else  {                                /* else you don't want to Fractalize, so segment */
  95.             if ((Len  > MinLen) && (p1->pen == DOWN))  {
  96.                 step = MinLen/Len;            /* step increment for parametric segmenting */
  97.                 for (t=step;t<1.0; t+=step) {
  98.                     p.x = p1->x + (p2->x - p1->x)*t;    /* calculate segment vertex position */
  99.                     p.y = p1->y + (p2->y - p1->y)*t; /* parametrically */
  100.                     p.pen = DOWN;
  101.                     addToPointList(pout,&p);     /* add each segment vertex */
  102.                     }
  103.                 }
  104.             addToPointList(pout,p2);    /* add the last point then carry on */
  105.             }
  106.         }
  107.     }
  108. }
  109.  
  110.  
  111.  
  112.